# -*- coding: utf-8 -*-
import re
import json
import os.path
import uuid
from typing import List, Tuple, Dict, Optional, Any

from loguru import logger
from pydantic import BaseModel
from fastapi import Request
from openai import OpenAI

from schemas.response_entity import JsonModel
from db.repository.dual_control_file import db_get_dc_file_by_id
from db.repository.conversation import db_add_conversation, db_save_dialog, db_search_dialog

# qwen-32B API 配置
API_KEY = "sk-6f89326783dd42b3b9c63284ef454cf2"
BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
MODEL_ID = "qwen3-32b"

# 三个sheet的三级字段映射（新的字段名称）
LEVEL_FIELDS = {
    "作业活动": {
        "level1": "风险点名称",
        "level2": "作业步骤",
        "level3": "作业内容"
    },
    "设备设施": {
        "level1": "风险点名称",
        "level2": "部位",
        "level3": "部件"
    },
    "场所": {
        "level1": "风险点名称",
        "level2": "区域",
        "level3": "位置"
    }
}

# 三个sheet的安全信息字段定义
SAFETY_FIELDS = {
    "作业活动": {
        "危险源": "危险源",
        "可能导致的事故类型": "可能导致的事故类型",
        "可能导致的事故描述": "可能导致的事故描述",
        "管控措施": "管控措施",
    },
    "设备设施": {
        "危险源": "危险源",
        "可能导致的事故类型": "可能导致的事故类型",
        "可能导致的事故描述": "可能导致的事故描述",
        "管控措施": "管控措施",
    },
    "场所": {
        "危险源": "危险源",
        "可能导致的事故类型": "可能导致的事故类型",
        "可能导致的事故描述": "可能导致的事故描述",
        "管控措施": "管控措施",
    }
}


# 从JSON文件中提取风险点信息并构建三级分离结构
def build_risk_level_from_json(data):
    """从JSON文件中提取风险点信息并构建三级分离结构，为每个sheet分别生成"""

    print("开始构建风险层级结构...")

    # 处理三个sheet：作业活动、设备设施、场所
    sheet_names = ["作业活动", "设备设施", "场所"]

    # 为每个sheet单独构建风险层级结构
    all_sheet_risk_levels = {}

    for sheet_name in sheet_names:
        # 检查sheet是否存在
        if sheet_name not in data or "data" not in data[sheet_name]:
            print(f"警告：JSON文件中不存在 '{sheet_name}' 或其data字段")
            all_sheet_risk_levels[sheet_name] = []
            continue

        level_mapping = LEVEL_FIELDS[sheet_name]
        print(f"正在处理 '{sheet_name}' sheet...")

        # 为当前sheet收集风险点组合
        sheet_risk_combinations = []

        for item in data[sheet_name]["data"]:
            # 提取三级风险点名称
            level1 = item.get(level_mapping["level1"], "").strip()
            level2 = item.get(level_mapping["level2"], "").strip()
            level3 = item.get(level_mapping["level3"], "").strip()

            # 过滤空值
            if not level1:
                continue

            # 构建完整结构
            sheet_risk_combinations.append((level1, level2, level3))

        print(f"  {sheet_name}: 收集到 {len(sheet_risk_combinations)} 个风险点组合")

        # 为当前sheet构建风险层级结构
        sheet_risk_level = {}
        processed_combinations = set()

        for level1, level2, level3 in sheet_risk_combinations:
            combination_key = f"{level1}_{level2}"

            if combination_key not in processed_combinations:
                # 创建这个组合的结构
                if level1 not in sheet_risk_level:
                    sheet_risk_level[level1] = {}

                if level2 and level2 not in sheet_risk_level[level1]:
                    sheet_risk_level[level1][level2] = {}

                processed_combinations.add(combination_key)

            # 添加三级风险点
            if level3 and level2:
                sheet_risk_level[level1][level2][level3] = {}

        # 转换为分离的结构（每个level1-level2组合作为独立的条目）
        separated_hierarchy = []

        for level1, level2_dict in sheet_risk_level.items():
            if level2_dict:  # 如果有二级分类
                for level2, level3_dict in level2_dict.items():
                    # 每个level1-level2组合作为独立的条目
                    item = {
                        level1: {
                            level2: level3_dict
                        }
                    }
                    separated_hierarchy.append(item)
            else:  # 如果没有二级分类，只有一级
                item = {level1: {}}
                separated_hierarchy.append(item)

        all_sheet_risk_levels[sheet_name] = separated_hierarchy
        print(f"  {sheet_name}: 构建完成，共 {len(separated_hierarchy)} 个风险层级结构")

    print(f"所有sheet构建完成")
    return all_sheet_risk_levels


# 保存所有sheet的风险等级结构
def save_all_sheet_risk_levels(all_sheet_risk_levels, output_dir):
    """保存所有sheet的风险层级结构到独立文件"""
    import os
    os.makedirs(output_dir, exist_ok=True)

    saved_files = []

    for sheet_name, risk_level in all_sheet_risk_levels.items():
        # 为每个sheet创建独立的文件名
        filename = f"risk_level_{sheet_name}.json"
        output_file = os.path.join(output_dir, filename)

        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(risk_level, f, ensure_ascii=False, indent=2)

        print(f"{sheet_name} 风险层级结构已保存到: {output_file}")
        saved_files.append(output_file)

    return saved_files


# 清理思考标签内容
def clean_think_tags(content):
    """
    清理内容中的<think></think>标签及其内容
    """
    if not content:
        return content

    # 删除<think></think>标签及其内容
    cleaned_content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL)
    # 清理多余的空行
    cleaned_content = re.sub(r'\n\s*\n\s*\n', '\n\n', cleaned_content)
    # 去除开头的空行
    cleaned_content = cleaned_content.strip()

    return cleaned_content


# 通用的qwen API调用函数
def call_qwen_api(prompt, system_message, use_stream):
    """
    调用 qwen3-32B API
    参数：
        prompt: 用户输入的提示
        system_message: 系统消息
        use_stream: 是否使用流式输出
    返回：
        API 响应的内容
    """
    try:
        client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

        if use_stream:
            # 流式输出
            response = client.chat.completions.create(
                model=MODEL_ID,
                messages=[
                    {"role": "system", "content": system_message},
                    {"role": "user", "content": prompt}
                ],
                stream=True,
                extra_body={"enable_thinking": True}
            )

            # 处理流式响应
            content = ""
            for chunk in response:
                if chunk.choices[0].delta.content is not None:
                    content += chunk.choices[0].delta.content

            return content
        else:
            # 非流式输出
            response = client.chat.completions.create(
                model=MODEL_ID,
                messages=[
                    {"role": "system", "content": system_message},
                    {"role": "user", "content": prompt}
                ],
                stream=False,
                extra_body={"enable_thinking": True}
            )

            return response.choices[0].message.content

    except Exception as e:
        print(f"调用 qwen API 失败: {e}")
        return None


# 调用qwen判断用户问题属于哪个风险点
def call_qwen(user_question, all_sheet_risk_levels):
    """调用qwen判断用户问题属于哪个风险点，返回多个可能的风险点"""

    output_example = """
        {
            "risk_levels": ["xxx", "xxx"],
            "作业活动": [
                {"level1": "xxx", "level2": "xxx", "level3": "xxx"},
                {"level1": "xxx", "level2": "xxx", "level3": "xxx"}
            ],
            "设备设施": [
                {"level1": "xxx", "level2": "xxx", "level3": "xxx"}
            ],
            "场所": [
                {"level1": "xxx", "level2": "", "level3": ""}
            ]
        }
    """

    # 构建提示词
    prompt = f"""
        你是一个港口作业安全专家。请根据用户的问题，分析该问题属于以下哪个风险点层级。

        预选的风险点分为三个类别，分别是作业活动、设备设施、场所。每个类别都是JSON结构，每个层级的名称都是有效的风险点。

        注意：
        1、JSON结构中，一级风险点是最外层的键名，二级风险点是第二层的键名，三级风险点是第三层的键名。

        作业活动风险点：
        {all_sheet_risk_levels.get("作业活动", [])}

        设备设施风险点：
        {all_sheet_risk_levels.get("设备设施", [])}

        场所风险点：
        {all_sheet_risk_levels.get("场所", [])}

        用户问题：{user_question}

        输出示例：{output_example}

        要求：
        1. 识别用户想查看的风险等级，可取的值只有这4个：[红、黄、橙、蓝]。
        2. 用户想要查看的风险等级可能有多个，把所有识别出的风险等级都输出到risk_levels数组中。
        3. 用户的问题可能较为模糊，会涉及到多种类别、多个风险点，返回所有的可能，按照相关性排序。
        4. 务必严格按照预选的风险点层级结构中的嵌套结构返回。
        5. 返回格式必须包含risk_levels字段和三个子表：作业活动、设备设施、场所，每个子表是数组格式。
        6. 数组中每个元素都是{{"level1": "xxx", "level2": "xxx", "level3": "xxx"}}格式。
        7. 若某个子表没有相关风险点，则该子表返回空数组[]。
        8. 若用户的问题不属于上述预选的风险点层级结构，则所有子表都返回空数组[]。
        9. 若用户没有指定风险等级，则risk_levels返回空数组[]。
        10. 若用户想要所有的风险，则risk_levels返回[红、黄、橙、蓝]。
        11. 只允许输出JSON对象，严禁输出其他任何解释说明的内容。
    """

    # 构建提示词
    system_message = "你是一个专业的港口作业安全专家，擅长分析作业场景和风险分类。请严格按照输入格式返回相同结构的JSON结果，包含三个子表的风险点匹配结果。"

    # 调用通用API函数
    result_text = call_qwen_api(prompt, system_message, use_stream=True)

    if not result_text:
        print("qwen API调用失败")
        return {"risk_levels": [], "作业活动": [], "设备设施": [], "场所": []}

    # 清理思考标签
    result_text = clean_think_tags(result_text)

    # 去掉 “```json” 和 “```”
    result_text = result_text.replace("```json", "").replace("```", "")

    try:
        result = json.loads(result_text)
        print(f"qwen返回的结果: {result}")

        # 确保返回的是正确的结构格式
        if isinstance(result, dict) and all(k in result for k in ["risk_levels", "作业活动", "设备设施", "场所"]):
            return result
        else:
            # 如果格式不正确，返回空结构
            return {
                "risk_levels": [],
                "作业活动": [],
                "设备设施": [],
                "场所": []
            }

    except json.JSONDecodeError:
        print(f"qwen返回的不是有效JSON: {result_text}")
        return {
            "risk_levels": [],
            "作业活动": [],
            "设备设施": [],
            "场所": []
        }


# 验证风险点是否符合预定义的嵌套结构
def validate_risk_levels(risk_levels_dict, all_sheet_risk_levels):
    """验证风险点是否符合预定义的嵌套结构，支持三个子表"""
    validated_dict = {
        "risk_levels": risk_levels_dict.get("risk_levels", []),
        "作业活动": [],
        "设备设施": [],
        "场所": []
    }

    # 遍历三个子表
    for sheet_name in ["作业活动", "设备设施", "场所"]:
        risk_levels_list = risk_levels_dict.get(sheet_name, [])
        sheet_risk_level = all_sheet_risk_levels.get(sheet_name, [])

        validated_list = []

        for risk_levels in risk_levels_list:
            level1 = risk_levels.get("level1", "")
            level2 = risk_levels.get("level2", "")
            level3 = risk_levels.get("level3", "")

            # 如果level1为空，跳过验证
            if not level1:
                validated_list.append({"level1": "", "level2": "", "level3": ""})
                continue

            # 在风险层级结构中查找是否存在这个组合
            is_valid = False

            for hierarchy_item in sheet_risk_level:
                # 每个hierarchy_item是一个字典，包含一个level1作为键
                if level1 in hierarchy_item:
                    level1_dict = hierarchy_item[level1]

                    # 如果level2为空，只验证level1
                    if not level2:
                        is_valid = True
                        break

                    # 验证level2存在
                    if level2 in level1_dict:
                        # 如果level3为空，只验证到level2即可（二级验证）
                        if not level3:
                            is_valid = True
                            break

                        # 如果level3不为空，必须验证完整的三级路径
                        level2_dict = level1_dict[level2]
                        if level3 in level2_dict:
                            is_valid = True
                            break

            if is_valid:
                validated_list.append(risk_levels)
                # 构建验证通过的路径显示
                path_parts = [level1]
                if level2:
                    path_parts.append(level2)
                if level3:
                    path_parts.append(level3)
                print(f"{sheet_name} 验证通过: {' -> '.join(path_parts)}")
            else:
                validated_list.append({"level1": "", "level2": "", "level3": ""})
                # 构建验证失败的路径显示
                path_parts = [level1]
                if level2:
                    path_parts.append(level2)
                if level3:
                    path_parts.append(level3)
                print(f"{sheet_name} 验证失败: {' -> '.join(path_parts)} (不符合预定义结构)")

        validated_dict[sheet_name] = validated_list

    return validated_dict


# 根据风险点层级查找对应的详细信息
def find_risk_details(risk_levels, risk_data, sheet_name):
    """根据风险点层级查找对应的详细信息，支持分表治理"""
    matching_items = []

    # 检查指定的sheet是否存在
    if sheet_name not in risk_data or "data" not in risk_data[sheet_name]:
        print(f"警告：{sheet_name} 表不存在或无数据")
        return matching_items

    # 获取指定sheet的字段映射
    level_mapping = LEVEL_FIELDS[sheet_name]

    for item in risk_data[sheet_name]["data"]:
        # 提取当前项的风险点信息
        level1 = item.get(level_mapping["level1"], "").strip()
        level2 = item.get(level_mapping["level2"], "").strip()
        level3 = item.get(level_mapping["level3"], "").strip()

        # 匹配逻辑：支持二级或三级风险匹配
        match = False

        # level1必须匹配
        if risk_levels.get("level1") and risk_levels["level1"] == level1:
            # 如果用户查询的level2为空，只要level1匹配即可
            if not risk_levels.get("level2"):
                match = True
            # 如果用户查询的level2不为空，则level2也必须匹配
            elif risk_levels.get("level2") == level2:
                # 如果用户查询的level3为空，只要level1和level2匹配即可
                if not risk_levels.get("level3"):
                    match = True
                # 如果用户查询的level3不为空，则需要level3也匹配
                elif risk_levels.get("level3") == level3:
                    match = True

        if match:
            matching_items.append(item)

    return matching_items


# 提取安全信息
def extract_safety_info(matching_items, sheet_name):
    """从命中的items中提取安全相关信息"""
    safety_items = []

    # 获取该sheet的安全字段定义
    safety_fields = SAFETY_FIELDS.get(sheet_name, {})
    # 获取该sheet的层级字段定义
    level_fields = LEVEL_FIELDS.get(sheet_name, {})

    for item in matching_items:
        # 提取每一项的完整安全信息
        safety_item = {}

        # 层级信息
        for field_key, field_name in level_fields.items():
            field_value = item.get(field_name, "").strip() if item.get(field_name) else ""
            safety_item[field_key] = field_value

        # 安全信息字段
        for field_key, field_name in safety_fields.items():
            field_value = item.get(field_name, "").strip() if item.get(field_name) else ""
            safety_item[field_key] = field_value

        safety_items.append(safety_item)

    return safety_items


# 将安全措施内容转换为HTML表格
def convert_safety_measures_to_html_table(safety_items, sheet_name):
    """将安全措施内容转换为简单HTML表格格式"""

    # 根据不同表类型设置表头 - 移除管控类型、管控依据列
    if sheet_name == "作业活动":
        headers = ["序号", "风险点名称", "作业步骤", "作业内容", "危险源", "事故类型", "事故描述", "管控措施"]
        field_keys = ["level1", "level2", "level3", "危险源", "可能导致的事故类型", "可能导致的事故描述", "管控措施"]
    elif sheet_name == "设备设施":
        headers = ["序号", "风险点名称", "部位", "部件", "危险源", "事故类型", "事故描述", "管控措施"]
        field_keys = ["level1", "level2", "level3", "危险源", "可能导致的事故类型", "可能导致的事故描述", "管控措施"]
    elif sheet_name == "场所":
        headers = ["序号", "风险点名称", "区域", "位置", "危险源", "事故类型", "事故描述", "管控措施"]
        field_keys = ["level1", "level2", "level3", "危险源", "可能导致的事故类型", "可能导致的事故描述", "管控措施"]

    # 构建简单HTML表格
    html_table = "<table border='1'>\n"

    # 表头
    html_table += "<tr>\n"
    for header in headers:
        html_table += f"<th>{header}</th>\n"
    html_table += "</tr>\n"

    # 表体
    for i, item in enumerate(safety_items, 1):
        html_table += "<tr>\n"
        html_table += f"<td>{i}</td>\n"

        for field_key in field_keys:
            value = item.get(field_key, '') or '无'
            # HTML转义特殊字符
            value = value.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
            html_table += f"<td>{value}</td>\n"

        html_table += "</tr>\n"

    html_table += "</table>\n"

    return html_table


# 生成指定表的安全报告
def generate_safety_report_sheet(user_question, risk_levels_list, risk_data, sheet_name, specified_risk_levels=None):
    """生成指定表的安全报告"""

    # 如果风险点列表为空，则返回空字符串
    if not risk_levels_list:
        return "", ""

    # 过滤有效风险点，只保留level1不为空的
    valid_risks = []
    for risk_levels in risk_levels_list:
        if risk_levels.get('level1'):
            valid_risks.append(risk_levels)

    if not valid_risks:
        return "", ""

    # 构建识别的风险点部分
    risk_points = []
    for i, risk_levels in enumerate(valid_risks, 1):
        level1 = risk_levels.get('level1', '未识别')
        level2 = risk_levels.get('level2', '')
        level3 = risk_levels.get('level3', '')

        # 根据不同表的字段含义构建显示
        if sheet_name == "作业活动":
            risk_point_text = f"""**风险点 {i}**：
  - 风险点名称：{level1}
  - 作业步骤：{level2 or '未识别'}
  - 作业内容：{level3 or '未识别'}"""
        elif sheet_name == "设备设施":
            risk_point_text = f"""**风险点 {i}**：
  - 风险点名称：{level1}
  - 部位：{level2 or '未识别'}
  - 部件：{level3 or '未识别'}"""
        elif sheet_name == "场所":
            risk_point_text = f"""**风险点 {i}**：
  - 风险点名称：{level1}
  - 区域：{level2 or '未识别'}
  - 位置：{level3 or '未识别'}"""

        risk_points.append(risk_point_text)

    risk_points_section = f"### {sheet_name}表\n\n" + "\n\n".join(risk_points)

    # 构建安全措施部分 - 使用表格形式
    # 构建安全措施部分 - 按风险等级分类
    risk_point_sections = []
    for i, risk_levels in enumerate(valid_risks, 1):
        # 查找该风险点的所有安全信息（不过滤风险等级）
        all_matching_items = find_risk_details(risk_levels, risk_data, sheet_name)

        # 构建风险点路径
        path_parts = [risk_levels.get('level1', '未识别')]
        if risk_levels.get('level2'):
            path_parts.append(risk_levels.get('level2'))
        if risk_levels.get('level3'):
            path_parts.append(risk_levels.get('level3'))
        risk_path = ' -> '.join(path_parts)

        # 按风险等级分类安全信息
        risk_level_groups = {}
        if all_matching_items:
            for item in all_matching_items:
                item_risk_level = item.get("风险等级", "").strip()
                if item_risk_level not in risk_level_groups:
                    risk_level_groups[item_risk_level] = []
                risk_level_groups[item_risk_level].append(item)

        # 构建该风险点的安全措施内容
        risk_section_parts = [f"**风险点 {i}**：{risk_path}\n"]

        # 按指定的风险等级显示（包括默认的橙色和黄色）
        for risk_level in specified_risk_levels:
            if risk_level in risk_level_groups:
                # 有该等级的安全信息
                safety_items = extract_safety_info(risk_level_groups[risk_level], sheet_name)
                html_table = convert_safety_measures_to_html_table(safety_items, sheet_name)
                risk_section_parts.append(f"**{risk_level}色等级：**\n\n{html_table}")
            else:
                # 没有该等级的安全信息
                risk_section_parts.append(f"**{risk_level}色等级：**\n\n暂无{risk_level}色等级的相关安全信息")

        risk_section = "\n\n".join(risk_section_parts)
        risk_point_sections.append(risk_section)

    safety_measures_section = f"### {sheet_name}表\n\n" + ("\n\n" + "-" * 50 + "\n\n").join(risk_point_sections)

    return risk_points_section, safety_measures_section


# 生成完整安全报告（拼接三个表的结果）
def generate_safety_report_direct(user_question, risk_levels_dict, risk_data):
    """生成完整的安全报告，拼接三个表的结果"""

    # 提取用户指定的风险等级
    specified_risk_levels = risk_levels_dict.get("risk_levels", [])

    # 如果用户没有指定风险等级，默认使用橙色和黄色
    if not specified_risk_levels:
        specified_risk_levels = ["橙", "黄"]
        print(f"用户未指定风险等级，默认使用: {specified_risk_levels}")

    # 收集所有风险点部分（报告前半部分）
    all_risk_points_sections = []

    # 收集所有安全措施部分（报告后半部分）
    all_safety_measures_sections = []

    # 处理三个表
    for sheet_name in ["作业活动", "设备设施", "场所"]:
        sheet_risk_levels = risk_levels_dict.get(sheet_name, [])
        if sheet_risk_levels:
            result = generate_safety_report_sheet(user_question, sheet_risk_levels, risk_data, sheet_name,
                                                  specified_risk_levels)
            if result and result[0]:  # 检查是否有返回结果
                risk_points_section, safety_measures_section = result
                all_risk_points_sections.append(risk_points_section)
                all_safety_measures_sections.append(safety_measures_section)

    # 拼接最终报告
    if not all_risk_points_sections:
        return """
## 识别的风险点

用户指定的风险等级：无

- 未识别到相关风险点，请重新提问

## 安全注意事项及措施

暂无相关安全信息
"""

    # 构建用户指定的风险等级显示
    risk_levels_text = "、".join(specified_risk_levels) + "色"

    # 拼接风险点部分
    risk_points_content = "\n\n".join(all_risk_points_sections)

    # 拼接安全措施部分
    safety_measures_content = ("\n\n" + "-" * 80 + "\n\n").join(all_safety_measures_sections)

    # 生成最终报告
    report = f"""
## 识别的风险点

风险等级：{risk_levels_text}
注：若用户未指定风险等级，默认使用橙色和黄色

{risk_points_content}

## 安全注意事项及措施

{safety_measures_content}"""

    return report


class ChatEntity(BaseModel):
    query: str
    dialog_id: Optional[uuid.UUID | str] = None
    token: str
    file_id: uuid.UUID = None


def pre_meeting_chat(request: Request, payload: ChatEntity):
    user = request.state.user  # 直接获取
    headers = None

    if payload.file_id is None:
        return JsonModel(code=404, data=None, msg=f"请选择双控清单文件").to_response(headers=headers)

    file = db_get_dc_file_by_id(payload.file_id)
    if not file or file.is_delete:
        return JsonModel(code=404, data=None, msg=f"选择文件不存在").to_response(headers=headers)

    user_id = user.id
    if payload.dialog_id:
        dialog = db_search_dialog(dialog_id=payload.dialog_id, user_id=user_id, dialog_type=2)
        if dialog is None:
            return JsonModel(code=404, data=None, msg=f"对话不存在,请更换对话").to_response(headers=headers)
    else:
        dialog = db_save_dialog(payload.query, user_id, dialog_type=2)

    from utils.file_utils import to_abs_path
    abs_loc = to_abs_path(file.location)
    output_dir = os.path.dirname(abs_loc)
    file_pure_path, suffix = abs_loc.rsplit('.', 1)
    json_file_path = f"{file_pure_path}.json"
    report_md_path = f"{file_pure_path}_report.md"

    with open(json_file_path, 'r', encoding='utf-8') as f:
        risk_data = json.load(f)

    # 基于原始数据构建三个sheet的风险层级结构，供LLM匹配与后续校验
    all_sheet_risk_levels = build_risk_level_from_json(risk_data)
    # 保存所有sheet的风险层级结构到独立文件
    saved_files = save_all_sheet_risk_levels(all_sheet_risk_levels, output_dir)
    print(f"所有风险层级结构文件已保存到: {output_dir}")

    user_question = payload.query

    # 1. 调用qwen判断风险点
    logger.debug(f"1.调用qwen判断风险点...")
    risk_levels_dict = call_qwen(user_question, all_sheet_risk_levels)
    logger.debug(f"qwen判断结果: {risk_levels_dict}")

    # 2. 验证风险点是否符合预定义结构
    print("\n正在验证风险点结构...")
    validated_risk_levels_dict = validate_risk_levels(risk_levels_dict, all_sheet_risk_levels)
    print(f"验证后的风险点结果: {validated_risk_levels_dict}")

    # 3. 生成安全报告
    logger.debug(f"2.正在生成安全作业指导报告...")
    safety_report = generate_safety_report_direct(user_question, validated_risk_levels_dict, risk_data)

    with open(report_md_path, 'w', encoding='utf-8') as f:
        f.write(safety_report)
    logger.debug(f"3.安全报告已保存到{report_md_path}")

    result = {
        "user_question": user_question,
        "identified_risk_levels": validated_risk_levels_dict,
        "safety_report": safety_report
    }
    conversation = db_add_conversation(user_question, answer=safety_report, dialog_id=dialog.id, references=result,
                                       file_id=payload.file_id)

    return JsonModel(code=200,
                     data={**result, "conversion": str(conversation.id), "dialog_id": str(dialog.id)},
                     msg="successful"
                     ).to_response()

